home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / IEditor / screen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-17  |  31.1 KB  |  1,447 lines
  1. /// Include
  2. #include <stdarg.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7.  
  8. #define INTUI_V36_NAMES_ONLY
  9. #define ASL_V38_NAMES_ONLY
  10. #define CATCOMP_NUMBERS
  11.  
  12. #include <exec/libraries.h>             // exec
  13. #include <exec/execbase.h>
  14. #include <intuition/intuition.h>        // intuition
  15. #include <intuition/screens.h>
  16. #include <dos/dos.h>                    // dos
  17. #include <dos/dosextens.h>
  18. #include <graphics/text.h>              // graphics
  19. #include <graphics/view.h>
  20. #include <libraries/gadtools.h>         // libraries
  21. #include <libraries/asl.h>
  22. #include <libraries/reqtools.h>
  23. #include <clib/exec_protos.h>           // protos
  24. #include <clib/intuition_protos.h>
  25. #include <clib/graphics_protos.h>
  26. #include <clib/dos_protos.h>
  27. #include <clib/diskfont_protos.h>
  28. #include <clib/locale_protos.h>
  29. #include <clib/asl_protos.h>
  30. #include <clib/reqtools_protos.h>
  31. #include <pragmas/exec_pragmas.h>       // pragmas
  32. #include <pragmas/intuition_pragmas.h>
  33. #include <pragmas/graphics_pragmas.h>
  34. #include <pragmas/dos_pragmas.h>
  35. #include <pragmas/locale_pragmas.h>
  36. #include <pragmas/asl_pragmas.h>
  37. #include <pragmas/reqtools_pragmas.h>
  38. #include <pragmas/gadtools_pragmas.h>
  39. #include <pragmas/diskfont_pragmas.h>
  40.  
  41.  
  42. #include "DEV_IE:defs.h"
  43. #include "DEV_IE:GUI.h"
  44. #include "DEV_IE:GUI_locale.h"
  45. #include "DEV_IE:Include/expander_pragmas.h"
  46. ///
  47. /// Prototipi
  48. static BOOL    ScrError( void );
  49. static void    LoadColors( UWORD );
  50. static void    WriteColors( UWORD );
  51. static void    GrabPalette( void );
  52. static void    HandleDriPens( void );
  53. static void    HandleScrTags( void );
  54. ///
  55. /// Tags varie
  56. static UWORD pens[] = { 0,1,1,2,1,3,1,0,2,1,2,1, ~0 };
  57.  
  58. static ULONG    ScreenTags2[] = {
  59.     SA_Width,       640,
  60.     SA_Height,      256,
  61.     SA_Depth,         2,
  62.     SA_DisplayID,   800,
  63.     SA_Font,        &ScrData.NewFont,
  64.     SA_Overscan,      0,
  65.     SA_AutoScroll,    0,
  66.     SA_Type,        CUSTOMSCREEN,
  67.     SA_Pens,        pens,
  68.     SA_Title,       0,
  69.     SA_PubName,     MyPubName,
  70.     TAG_END
  71. };
  72.  
  73. static ULONG MenuTag[] = { GTMN_NewLookMenus, TRUE, TAG_END };
  74.  
  75. static ULONG palreq_tags[] = { RT_ReqPos, REQPOS_CENTERSCR, TAG_END };
  76. ///
  77. /// Dati
  78. static ULONG PaletteChunk[] = { 'FORM', 0, 'ILBM', 'CMAP', 0 };
  79.  
  80. static UBYTE Title[ 200 ], PubName[ 200 ];
  81.  
  82. static UWORD pens_backup[12];
  83.  
  84. UBYTE   PalettePattern[] = "(#?.ilbm|#?.iff|#?.col|#?.pal)";
  85. UBYTE   ScrPattern[] = "#?.scr";
  86.  
  87. static UBYTE FontScr[ 256 ] = "topaz.font";
  88.  
  89. struct ScreenInfo ScrData = {
  90.     NULL,                           // Visual Info
  91.     0,                              // YOffset
  92.     FontScr, 8, 0, 1,
  93.     SC_SHOWTITLE | SC_DRAGGABLE,
  94.     0, 0,                           // Left, Top
  95.     0,                              // Type
  96.     FontScr,
  97.     Title,
  98.     PubName,
  99.     ScreenTags2,
  100.     pens
  101. };
  102. ///
  103.  
  104.  
  105. /// LayoutWindow & PostOpenWindow
  106. void LayoutWindow( struct TagItem *tags )
  107. {
  108.     tags[ WT_HEIGHT ].ti_Data += (YOffset - 10);
  109.  
  110.     tags[ WT_LEFT ].ti_Data = (Scr->Width  - tags[ WT_WIDTH  ].ti_Data) >> 1;
  111.     tags[ WT_TOP  ].ti_Data = (Scr->Height - tags[ WT_HEIGHT ].ti_Data) >> 1;
  112. }
  113.  
  114.  
  115. void PostOpenWindow( struct TagItem *tags )
  116. {
  117.     tags[ WT_HEIGHT ].ti_Data -= (YOffset - 10);
  118. }
  119. ///
  120.  
  121. /// Routines di I/O
  122. BOOL SalvaScrMenued( void )
  123. {
  124.     LockAllWindows();
  125.  
  126.     if ( GetFile2( TRUE, CatCompArray[ ASL_SAVE_SCR ].cca_Str,
  127.           ScrPattern, ASL_SAVE_SCR, "scr" )) {
  128.  
  129.     if ( File = Open( allpath, MODE_NEWFILE )) {
  130.         FWrite( File, DataHeader, 8, 1 );
  131.         FWrite( File, &ScrHeader, 4, 1 );
  132.         WriteScr();
  133.         Close( File );
  134.     } else
  135.         Stat( CatCompArray[ ERR_IOERR ].cca_Str, TRUE, ERR_IOERR );
  136.     }
  137.  
  138.     UnlockAllWindows();
  139.  
  140.     return( TRUE );
  141. }
  142.  
  143. void WriteScr( void )
  144. {
  145.     WORD    *data = ScreenTags2;
  146.  
  147.     FWrite( File, &data[( SCRWIDTH      * 2 ) + 1 ], 2, 1 );
  148.     FWrite( File, &data[( SCRHEIGHT     * 2 ) + 1 ], 2, 1 );
  149.     FWrite( File, &data[( SCRDEPTH      * 2 ) + 1 ], 2, 1 );
  150.     FWrite( File, &data[  SCRID         * 2 ], 4, 1 );
  151.     FWrite( File, &data[  SCROVERSCAN   * 2 ], 4, 1 );
  152.     FWrite( File, &data[( SCRAUTOSCROLL * 2 ) + 1 ], 2, 1 );
  153.     FWrite( File, &ScrData.NewFont.ta_YSize, 4, 1 );
  154.     FWrite( File, &ScrData.ScrAttrs, 2, 1 );
  155.     FWrite( File, &ScrData.St_Left, 2, 1 );
  156.     FWrite( File, &ScrData.St_Top, 2, 1 );
  157.     FWrite( File, &ScrData.Type, 2, 1 );
  158.     FWrite( File, pens, 24, 1 );
  159.     PutString( FontScr );
  160.     PutString( Title );
  161.     PutString( PubName );
  162.     WriteColors( 1 << ScreenTags2[ SCRDEPTH ] );
  163. }
  164.  
  165.  
  166. BOOL CaricaColMenued( void )
  167. {
  168.     ULONG   b1, b2;
  169.  
  170.     LockAllWindows();
  171.  
  172.     if ( GetFile2( FALSE, CatCompArray[ ASL_LOAD_PALETTE ].cca_Str,
  173.           PalettePattern, ASL_LOAD_PALETTE, "ilbm" )) {
  174.  
  175.     if ( File = Open( allpath, MODE_OLDFILE )) {
  176.  
  177.         Read( File, &b1, 4 );
  178.         Read( File, &b2, 4 );
  179.         Read( File, &b2, 4 );
  180.  
  181.         if (( b1 == 'FORM' ) && ( b2 == 'ILBM' )) {
  182.  
  183.         Read( File, &b1, 4 );
  184.         Read( File, &b2, 4 );
  185.  
  186.         while( b1 != 'CMAP' || b2 == 0 ) {
  187.             Seek( File, b2, OFFSET_CURRENT );
  188.             if ( b2 = Read( File, &b1, 4 ))
  189.             Read( File, &b2, 4 );
  190.         }
  191.  
  192.         if ( b2 != 0 )
  193.             LoadColors( b2 / 3 );
  194.         else
  195.             Stat( CatCompArray[ ERR_NO_CMAP ].cca_Str, TRUE, ERR_NO_CMAP );
  196.  
  197.         } else
  198.         Stat( CatCompArray[ ERR_NOT_ILBM ].cca_Str, TRUE, ERR_NOT_ILBM );
  199.  
  200.         Close( File );
  201.     } else
  202.         Stat( CatCompArray[ ERR_IOERR ].cca_Str, TRUE, ERR_IOERR );
  203.     }
  204.     UnlockAllWindows();
  205.     return( TRUE );
  206. }
  207.  
  208.  
  209.  
  210. void LoadColors( UWORD num )
  211. {
  212.     UWORD   c, c2, c3;
  213.     UBYTE   buf[3];
  214.  
  215.     if ( IE.colortable )  FreeVec( IE.colortable );
  216.  
  217.     c = 1 << ScreenTags2[ SCRDEPTH ];
  218.     if ( num > c )  num = c;
  219.  
  220.     if ( SysBase->LibNode.lib_Version >= 39 ) {  // Kick 3.0
  221.  
  222.     ULONG  *ptr;
  223.     if ( ptr = IE.colortable = AllocVec(( num * 12 ) + 8, 0L )) {
  224.  
  225.         *((UWORD *)ptr)++ = num;
  226.         *((UWORD *)ptr)++ = 0;
  227.  
  228.         for( c = 0; c < num; c++ ) {
  229.  
  230.         FRead( File, buf, 3, 1 );
  231.         for( c2 = 0; c2 < 3 ; c2++ ) {
  232.             c3 = (buf[ c2 ] << 8) | buf[ c2 ];
  233.             *ptr++ = c3 | ( c3 << 16 );
  234.         }
  235.         }
  236.         *ptr = NULL;
  237.  
  238.         LoadRGB32( &Scr->ViewPort, IE.colortable );
  239.  
  240.     } else {
  241.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  242.         return;
  243.     }
  244.     } else {                             // Kick 2.0
  245.  
  246.     UWORD *ptr2;
  247.     if( ptr2 = IE.colortable = AllocVec( num + num + 2, 0L )) {
  248.  
  249.         *ptr2++ = num;
  250.  
  251.         for( c2 = 0; c2 < num; c2 ++ ) {
  252.         FRead( File, buf, 3, 1 );
  253.         *ptr2++ = (buf[0] << 4) | buf[1] | (buf[2] >> 4);
  254.         }
  255.  
  256.         LoadRGB4( &Scr->ViewPort, (APTR)((ULONG)IE.colortable+2), num );
  257.  
  258.     } else {
  259.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  260.     }
  261.     }
  262. }
  263.  
  264.  
  265. BOOL SalvaColMenued( void )
  266. {
  267.     UWORD   num, bytes;
  268.  
  269.     LockAllWindows();
  270.  
  271.     if( GetFile2( TRUE, CatCompArray[ ASL_SAVE_PALETTE ].cca_Str,
  272.          PalettePattern, ASL_SAVE_PALETTE, "ilbm" )) {
  273.  
  274.     if ( File = Open( allpath, MODE_NEWFILE )) {
  275.  
  276.         num = 1 << ScreenTags2[ SCRDEPTH ];
  277.  
  278.         PaletteChunk[4] = bytes = num * 3;
  279.         PaletteChunk[1] = bytes + 12;
  280.  
  281.         FWrite( File, PaletteChunk, 20, 1 );
  282.  
  283.         WriteColors( num );
  284.  
  285.         Close( File );
  286.  
  287.     } else {
  288.         Stat( CatCompArray[ ERR_IOERR ].cca_Str, TRUE, ERR_IOERR );
  289.     }
  290.     }
  291.  
  292.     UnlockAllWindows();
  293.     return( TRUE );
  294. }
  295.  
  296.  
  297. void WriteColors( UWORD num )
  298. {
  299.     UBYTE   *mem, *mem2;
  300.     int     cnt, col;
  301.  
  302.     if( SysBase->LibNode.lib_Version >= 39 ) {      // Kick 3.0+
  303.  
  304.     if (mem = mem2 = AllocVec( num * 12, 0L )) {
  305.  
  306.         GetRGB32( Scr->ViewPort.ColorMap, 0, num, (ULONG *)mem );
  307.  
  308.         for( cnt = 0; cnt < num; cnt++ ) {
  309.         mem += 3;
  310.         FPutC( File, *mem++ );
  311.         mem += 3;
  312.         FPutC( File, *mem++ );
  313.         mem += 3;
  314.         FPutC( File, *mem++ );
  315.         }
  316.         FreeVec( mem2 );
  317.  
  318.     } else {
  319.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  320.     }
  321.     } else {                                // Kick 2.0
  322.  
  323.     for( cnt = 0; cnt < num; cnt++ ) {
  324.  
  325.         col = GetRGB4( Scr->ViewPort.ColorMap, cnt );
  326.  
  327.         FPutC( File, ( col >> 4 ) & 0xF0 );
  328.         FPutC( File,   col        & 0xF0 );
  329.         FPutC( File, ( col << 4 ) & 0xF0 );
  330.     }
  331.  
  332.     }
  333. }
  334. ///
  335.  
  336. /// Grab Palette
  337. void GrabPalette( void )
  338. {
  339.     UWORD   num = 1 << ScreenTags2[ SCRDEPTH ];
  340.     int     cnt;
  341.  
  342.     if( IE.colortable )
  343.     FreeVec( IE.colortable );
  344.  
  345.     if ( SysBase->LibNode.lib_Version >= 39 ) {         // Kick 3.0+
  346.  
  347.     if ( IE.colortable = AllocVec(( num * 12 ) + 8, 0L )) {
  348.  
  349.         ULONG *ptr = IE.colortable;
  350.  
  351.         *ptr++ = num << 16;
  352.  
  353.         GetRGB32( Scr->ViewPort.ColorMap, 0, num, ptr );
  354.  
  355.         ptr[ num * 3 ] = NULL;
  356.     }
  357.  
  358.     } else {                                    // Kick 2.0
  359.  
  360.     if ( IE.colortable = AllocVec( num + num + 2, 0L )) {
  361.  
  362.         UWORD  *ptr2 = IE.colortable;
  363.  
  364.         *ptr2++ = num;
  365.  
  366.         for( cnt = 0; cnt < num; cnt++ )
  367.         *ptr2++ = GetRGB4( Scr->ViewPort.ColorMap, cnt );
  368.  
  369.     }
  370.  
  371.     }
  372. }
  373. ///
  374.  
  375. /// Palette
  376. BOOL ChangeColMenued( void )
  377. {
  378.     LockAllWindows();
  379.  
  380.     rtPaletteRequestA( CatCompArray[ REQ_MODIFY_PALETTE ].cca_Str,
  381.                NULL, (struct TagItem *)palreq_tags );
  382.  
  383.     GrabPalette();
  384.  
  385.     if( IE.flags_2 & GENERASCR )
  386.     IE.flags &= ~SALVATO;
  387.  
  388.     UnlockAllWindows();
  389.  
  390.     return( TRUE );
  391. }
  392. ///
  393.  
  394. /// DriPens
  395. static ULONG    DP_PaletteTag[] = { GTPA_Color, 0, TAG_END };
  396. static ULONG    DP_CycleTag[]   = { GTCY_Active, 0, TAG_END };
  397. static BOOL     DP_Ret;
  398.  
  399. BOOL DriPensMenued( void )
  400. {
  401.     ULONG   *ptr;
  402.     BOOL    ret;
  403.     int     cnt;
  404.  
  405.     if( DriPensWnd ) {
  406.     ActivateWindow( DriPensWnd );
  407.     WindowToFront( DriPensWnd );
  408.     return( TRUE );
  409.     }
  410.  
  411.     DP_Ret = FALSE;
  412.  
  413.     for( cnt = 0; cnt < 12; cnt++ )
  414.     pens_backup[ cnt ] = pens[ cnt ];
  415.  
  416.     ptr = DriPensGTags;
  417.     while( *ptr++ != GTPA_Depth );
  418.     *ptr = ScreenTags2[ SCRDEPTH ];
  419.  
  420.     LayoutWindow( DriPensWTags );
  421.     ret = OpenDriPensWindow();
  422.     PostOpenWindow( DriPensWTags );
  423.  
  424.     if ( ret ) {
  425.     CloseDriPensWindow();
  426.     DisplayBeep( Scr );
  427.     } else {
  428.  
  429.     DP_PaletteTag[1] = pens[0];
  430.  
  431.     GT_SetGadgetAttrsA( DriPensGadgets[ GD_DP_Pal ], DriPensWnd,
  432.                NULL, (struct TagItem *)DP_PaletteTag );
  433.  
  434.     DP_CycleTag[1]   = 0;
  435.  
  436.     DriPensWnd->ExtData = HandleDriPens;
  437.     }
  438.  
  439.     return( TRUE );
  440. }
  441.  
  442. void HandleDriPens( void )
  443. {               
  444.     if(!( HandleDriPensIDCMP() )) {
  445.     CloseDriPensWindow();
  446.  
  447.     if( DP_Ret )
  448.         UpdateScr();
  449.     }
  450. }
  451.  
  452. BOOL DriPensVanillaKey( void )
  453. {
  454.     switch( IDCMPMsg.Code ) {
  455.     case 13:
  456.         return( DP_OkClicked() );
  457.     case 27:
  458.         return( DP_AnnClicked() );
  459.     }
  460.     return( TRUE );
  461. }
  462.  
  463. BOOL DP_OkKeyPressed( void )
  464. {
  465.     return( DP_OkClicked() );
  466. }
  467.  
  468. BOOL DP_OkClicked( void )
  469. {
  470.     DP_Ret = TRUE;
  471.     return( FALSE );
  472. }
  473.  
  474. BOOL DP_AnnKeyPressed( void )
  475. {
  476.     return( FALSE );
  477. }
  478.  
  479. BOOL DP_AnnClicked( void )
  480. {
  481.     ULONG   cnt;
  482.  
  483.     for( cnt = 0; cnt < 12; cnt++ )
  484.     pens[ cnt ] = pens_backup[ cnt ];
  485.  
  486.     return( FALSE );
  487. }
  488.  
  489.  
  490. BOOL DP_PensKeyPressed( void )
  491. {
  492.     if( IDCMPMsg.Code & 0x20 ) {
  493.     if ( DP_CycleTag[1] < 12 )
  494.         DP_CycleTag[1] += 1;
  495.     else
  496.         DP_CycleTag[1] = 0;
  497.     } else {
  498.     if( DP_CycleTag[1] )
  499.         DP_CycleTag[1] -= 1;
  500.     else
  501.         DP_CycleTag[1] = 11;
  502.     }
  503.  
  504.     IDCMPMsg.Code = DP_CycleTag[1];
  505.  
  506.     GT_SetGadgetAttrsA( DriPensGadgets[ GD_DP_Pens ], DriPensWnd,
  507.             NULL, (struct TagItem *)DP_CycleTag );
  508.  
  509.     return( DP_PensClicked() );
  510. }
  511.  
  512.  
  513. BOOL DP_PensClicked( void )
  514. {
  515.     DP_PaletteTag[1] = pens[ IDCMPMsg.Code ];
  516.  
  517.     GT_SetGadgetAttrsA( DriPensGadgets[ GD_DP_Pal ], DriPensWnd,
  518.             NULL, (struct TagItem *)DP_PaletteTag );
  519.  
  520.     return( TRUE );
  521. }
  522.  
  523.  
  524. BOOL DP_PalKeyPressed( void )
  525. {
  526.     ULONG   n = DP_CycleTag[1];
  527.     ULONG   max = ( 1 << ScreenTags2[ SCRDEPTH ]) - 1;
  528.  
  529.     if( IDCMPMsg.Code & 0x20 ) {
  530.     if ( pens[n] < max )
  531.         pens[n] += 1;
  532.     else
  533.         pens[n] = 0;
  534.     } else {
  535.     if( pens[n] )
  536.         pens[n] -= 1;
  537.     else
  538.         pens[n] = max;
  539.     }
  540.  
  541.     DP_PaletteTag[1] = pens[ n ];
  542.  
  543.     GT_SetGadgetAttrsA( DriPensGadgets[ GD_DP_Pal ], DriPensWnd,
  544.             NULL, (struct TagItem *)DP_PaletteTag );
  545.  
  546.     return( TRUE );
  547. }
  548.  
  549.  
  550. BOOL DP_PalClicked( void )
  551. {
  552.     pens[ DP_CycleTag[1] ] = IDCMPMsg.Code;
  553.  
  554.     return( TRUE );
  555. }
  556. ///
  557.  
  558. /// Screen Tags
  559. static  UWORD   ScrAttrsBack;
  560. static  ULONG   ST_CycleTag[] = { GTCY_Active, 0, TAG_END };
  561.  
  562. BOOL ScrTagsMenued( void )
  563. {
  564.     int             ret, code;
  565.     static UWORD    gads[] = {
  566.             GD_ScrT_Left,
  567.             GD_ScrT_Top,
  568.             GD_ScrT_ShowTit,
  569.             GD_ScrT_Behind,
  570.             GD_ScrT_Quiet,
  571.             GD_ScrT_Overscan,
  572.             GD_ScrT_FullPal,
  573.             GD_ScrT_Error,
  574.             GD_ScrT_Drag,
  575.             GD_ScrT_Exclusive,
  576.             GD_ScrT_SharePens,
  577.             GD_ScrT_Interleaved,
  578.             GD_ScrT_LikeWB,
  579.             GD_ScrT_MinISG
  580.             };
  581.  
  582.     if( ScrTagsWnd ) {
  583.     ActivateWindow( ScrTagsWnd );
  584.     WindowToFront( ScrTagsWnd );
  585.     return( TRUE );
  586.     }
  587.  
  588.     LayoutWindow( ScrTagsWTags );
  589.     ret = OpenScrTagsWindow();
  590.     PostOpenWindow( ScrTagsWTags );
  591.  
  592.     if( ret ) {
  593.     DisplayBeep( Scr );
  594.     CloseScrTagsWindow();
  595.     } else {
  596.  
  597.     ScrAttrsBack = ScrData.ScrAttrs;
  598.  
  599.     code = 1;
  600.     for( ret = 0; ret < 14; ret ++ ) {
  601.  
  602.         CheckedTag[1] = ( ScrData.ScrAttrs & code) ? TRUE : FALSE;
  603.         GT_SetGadgetAttrsA( ScrTagsGadgets[ gads[ ret ]], ScrTagsWnd,
  604.                 NULL, (struct TagItem *)CheckedTag );
  605.  
  606.         code <<= 1;
  607.     }
  608.  
  609.     StringTag[1] = Title;
  610.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_TitIn ], ScrTagsWnd,
  611.                 NULL, (struct TagItem *)StringTag );
  612.  
  613.     StringTag[1] = PubName;
  614.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_PubNameIn ], ScrTagsWnd,
  615.                 NULL, (struct TagItem *)StringTag );
  616.  
  617.     DisableTag[1] = ( ScrData.ScrAttrs & 1 ) ? FALSE : TRUE;
  618.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_LeftIn ], ScrTagsWnd,
  619.                 NULL, (struct TagItem *)DisableTag );
  620.  
  621.     DisableTag[1] = ( ScrData.ScrAttrs & 2 ) ? FALSE : TRUE;
  622.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_TopIn ], ScrTagsWnd,
  623.                 NULL, (struct TagItem *)DisableTag );
  624.  
  625.     IntegerTag[1] = ScrData.St_Left;
  626.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_LeftIn ], ScrTagsWnd,
  627.                 NULL, (struct TagItem *)IntegerTag );
  628.  
  629.     IntegerTag[1] = ScrData.St_Top;
  630.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_TopIn ], ScrTagsWnd,
  631.                 NULL, (struct TagItem *)IntegerTag );
  632.  
  633.     ST_CycleTag[1] = ScrData.Type;
  634.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Type ], ScrTagsWnd,
  635.                 NULL, (struct TagItem *)ST_CycleTag );
  636.  
  637.     ScrTagsWnd->ExtData = HandleScrTags;
  638.     }
  639.  
  640.     return( TRUE );
  641. }
  642.  
  643. void HandleScrTags( void )
  644. {
  645.     if(!( HandleScrTagsIDCMP() ))
  646.     CloseScrTagsWindow();
  647. }
  648.  
  649. BOOL ScrTagsVanillaKey( void )
  650. {
  651.     switch( IDCMPMsg.Code ) {
  652.     case 13:
  653.         return( ScrT_OkClicked() );
  654.     case 27:
  655.         return( ScrT_AnnullaClicked() );
  656.     }
  657.  
  658.     return( TRUE );
  659. }
  660.  
  661. BOOL ScrT_AnnullaKeyPressed( void )
  662. {
  663.     return( ScrT_AnnullaClicked() );
  664. }
  665.  
  666. BOOL ScrT_AnnullaClicked( void )
  667. {
  668.     ScrData.ScrAttrs = ScrAttrsBack;
  669.     return( FALSE );
  670. }
  671.  
  672. BOOL ScrT_OkKeyPressed( void )
  673. {
  674.     return( ScrT_OkClicked() );
  675. }
  676.  
  677. BOOL ScrT_OkClicked( void )
  678. {
  679.  
  680.     strcpy( Title,   GetString( ScrTagsGadgets[ GD_ScrT_TitIn     ]) );
  681.     strcpy( PubName, GetString( ScrTagsGadgets[ GD_ScrT_PubNameIn ]) );
  682.  
  683.     ScrData.St_Left = GetNumber( ScrTagsGadgets[ GD_ScrT_LeftIn ]);
  684.     ScrData.St_Top  = GetNumber( ScrTagsGadgets[ GD_ScrT_TopIn  ]);
  685.  
  686.     IE.flags &= ~SALVATO;
  687.  
  688.     return( FALSE );
  689. }
  690.  
  691. BOOL ScrT_LeftInClicked( void )
  692. {
  693.     return( TRUE );
  694. }
  695.  
  696. BOOL ScrT_TopInClicked( void )
  697. {
  698.     return( TRUE );
  699. }
  700.  
  701. BOOL ScrT_TitInClicked( void )
  702. {
  703.     return( TRUE );
  704. }
  705.  
  706. BOOL ScrT_PubNameInClicked( void )
  707. {
  708.     return( TRUE );
  709. }
  710.  
  711. BOOL ScrT_LeftKeyPressed( void )
  712. {
  713.     IDCMPMsg.Code = CheckedTag[1] = ( ScrData.ScrAttrs & SC_LEFT ) ? TRUE : FALSE;
  714.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Left ], ScrTagsWnd,
  715.             NULL, (struct TagItem *)CheckedTag );
  716.  
  717.     return( ScrT_LeftClicked() );
  718. }
  719.  
  720. BOOL ScrT_LeftClicked( void )
  721. {
  722.     DisableTag[1] = !IDCMPMsg.Code;
  723.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_LeftIn ], ScrTagsWnd,
  724.             NULL, (struct TagItem *)DisableTag );
  725.  
  726.     if(!( DisableTag[1] ))
  727.     ActivateGadget( ScrTagsGadgets[ GD_ScrT_LeftIn ], ScrTagsWnd, NULL );
  728.  
  729.     ScrData.ScrAttrs ^= SC_LEFT;
  730.  
  731.     return( TRUE );
  732. }
  733.  
  734. BOOL ScrT_TopKeyPressed( void )
  735. {
  736.     IDCMPMsg.Code = CheckedTag[1] = ( ScrData.ScrAttrs & SC_TOP ) ? TRUE : FALSE;
  737.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Top ], ScrTagsWnd,
  738.             NULL, (struct TagItem *)CheckedTag );
  739.  
  740.     return( ScrT_TopClicked() );
  741. }
  742.  
  743. BOOL ScrT_TopClicked( void )
  744. {
  745.     DisableTag[1] = !IDCMPMsg.Code;
  746.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_TopIn ], ScrTagsWnd,
  747.             NULL, (struct TagItem *)DisableTag );
  748.  
  749.     if(!( DisableTag[1] ))
  750.     ActivateGadget( ScrTagsGadgets[ GD_ScrT_TopIn ], ScrTagsWnd, NULL );
  751.  
  752.     ScrData.ScrAttrs ^= SC_TOP;
  753.  
  754.     return( TRUE );
  755. }
  756.  
  757. BOOL ScrT_ShowTitKeyPressed( void )
  758. {
  759.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_SHOWTITLE ) ? TRUE : FALSE;
  760.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_ShowTit ], ScrTagsWnd,
  761.             NULL, (struct TagItem *)CheckedTag );
  762.  
  763.     return( ScrT_ShowTitClicked() );
  764. }
  765.  
  766. BOOL ScrT_ShowTitClicked( void )
  767. {
  768.     ScrData.ScrAttrs ^= SC_SHOWTITLE;
  769.     return( TRUE );
  770. }
  771.  
  772. BOOL ScrT_BehindKeyPressed( void )
  773. {
  774.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_BEHIND ) ? TRUE : FALSE;
  775.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Behind ], ScrTagsWnd,
  776.             NULL, (struct TagItem *)CheckedTag );
  777.  
  778.     return( ScrT_BehindClicked() );
  779. }
  780.  
  781. BOOL ScrT_BehindClicked( void )
  782. {
  783.     ScrData.ScrAttrs ^= SC_BEHIND;
  784.     return( TRUE );
  785. }
  786.  
  787. BOOL ScrT_QuietKeyPressed( void )
  788. {
  789.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_QUIET ) ? TRUE : FALSE;
  790.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Quiet ], ScrTagsWnd,
  791.             NULL, (struct TagItem *)CheckedTag );
  792.  
  793.     return( ScrT_QuietClicked() );
  794. }
  795.  
  796. BOOL ScrT_QuietClicked( void )
  797. {
  798.     ScrData.ScrAttrs ^= SC_QUIET;
  799.     return( TRUE );
  800. }
  801.  
  802. BOOL ScrT_OverscanKeyPressed( void )
  803. {
  804.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_OVERSCAN ) ? TRUE : FALSE;
  805.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Overscan ], ScrTagsWnd,
  806.             NULL, (struct TagItem *)CheckedTag );
  807.  
  808.     return( ScrT_OverscanClicked() );
  809. }
  810.  
  811. BOOL ScrT_OverscanClicked( void )
  812. {
  813.     ScrData.ScrAttrs ^= SC_OVERSCAN;
  814.     return( TRUE );
  815. }
  816.  
  817. BOOL ScrT_FullPalKeyPressed( void )
  818. {
  819.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_FULLPALETTE ) ? TRUE : FALSE;
  820.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_FullPal ], ScrTagsWnd,
  821.             NULL, (struct TagItem *)CheckedTag );
  822.  
  823.     return( ScrT_FullPalClicked() );
  824. }
  825.  
  826. BOOL ScrT_FullPalClicked( void )
  827. {
  828.     ScrData.ScrAttrs ^= SC_FULLPALETTE;
  829.     return( TRUE );
  830. }
  831.  
  832. BOOL ScrT_ErrorKeyPressed( void )
  833. {
  834.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_ERRORCODE ) ? TRUE : FALSE;
  835.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Error ], ScrTagsWnd,
  836.             NULL, (struct TagItem *)CheckedTag );
  837.  
  838.     return( ScrT_ErrorClicked() );
  839. }
  840.  
  841. BOOL ScrT_ErrorClicked( void )
  842. {
  843.     ScrData.ScrAttrs ^= SC_ERRORCODE;
  844.     return( TRUE );
  845. }
  846.  
  847. BOOL ScrT_DragKeyPressed( void )
  848. {
  849.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_DRAGGABLE ) ? TRUE : FALSE;
  850.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Drag ], ScrTagsWnd,
  851.             NULL, (struct TagItem *)CheckedTag );
  852.  
  853.     return( ScrT_DragClicked() );
  854. }
  855.  
  856. BOOL ScrT_DragClicked( void )
  857. {
  858.     ScrData.ScrAttrs ^= SC_DRAGGABLE;
  859.     return( TRUE );
  860. }
  861.  
  862. BOOL ScrT_ExclusiveKeyPressed( void )
  863. {
  864.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_EXCLUSIVE ) ? TRUE : FALSE;
  865.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Exclusive ], ScrTagsWnd,
  866.             NULL, (struct TagItem *)CheckedTag );
  867.  
  868.     return( ScrT_ExclusiveClicked() );
  869. }
  870.  
  871. BOOL ScrT_ExclusiveClicked( void )
  872. {
  873.     ScrData.ScrAttrs ^= SC_EXCLUSIVE;
  874.     return( TRUE );
  875. }
  876.  
  877. BOOL ScrT_SharePensKeyPressed( void )
  878. {
  879.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_SHAREPENS ) ? TRUE : FALSE;
  880.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_SharePens ], ScrTagsWnd,
  881.             NULL, (struct TagItem *)CheckedTag );
  882.  
  883.     return( ScrT_SharePensClicked() );
  884. }
  885.  
  886. BOOL ScrT_SharePensClicked( void )
  887. {
  888.     ScrData.ScrAttrs ^= SC_SHAREPENS;
  889.     return( TRUE );
  890. }
  891.  
  892. BOOL ScrT_InterleavedKeyPressed( void )
  893. {
  894.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_INTERLEAVED ) ? TRUE : FALSE;
  895.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Interleaved ], ScrTagsWnd,
  896.             NULL, (struct TagItem *)CheckedTag );
  897.  
  898.     return( ScrT_InterleavedClicked() );
  899. }
  900.  
  901. BOOL ScrT_InterleavedClicked( void )
  902. {
  903.     ScrData.ScrAttrs ^= SC_INTERLEAVED;
  904.     return( TRUE );
  905. }
  906.  
  907. BOOL ScrT_LikeWBKeyPressed( void )
  908. {
  909.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_LIKEWORKBENCH ) ? TRUE : FALSE;
  910.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_LikeWB ], ScrTagsWnd,
  911.             NULL, (struct TagItem *)CheckedTag );
  912.  
  913.     return( ScrT_LikeWBClicked() );
  914. }
  915.  
  916. BOOL ScrT_LikeWBClicked( void )
  917. {
  918.     ScrData.ScrAttrs ^= SC_LIKEWORKBENCH;
  919.     return( TRUE );
  920. }
  921.  
  922. BOOL ScrT_MinISGKeyPressed( void )
  923. {
  924.     CheckedTag[1] = ( ScrData.ScrAttrs & SC_MINIMIZEISG ) ? TRUE : FALSE;
  925.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_MinISG ], ScrTagsWnd,
  926.             NULL, (struct TagItem *)CheckedTag );
  927.  
  928.     return( ScrT_MinISGClicked() );
  929. }
  930.  
  931. BOOL ScrT_MinISGClicked( void )
  932. {
  933.     ScrData.ScrAttrs ^= SC_MINIMIZEISG;
  934.     return( TRUE );
  935. }
  936.  
  937. BOOL ScrT_TypeKeyPressed( void )
  938. {
  939.     ScrData.Type = ST_CycleTag[1] = ST_CycleTag[1] ? 0 : 1;
  940.     GT_SetGadgetAttrsA( ScrTagsGadgets[ GD_ScrT_Type ], ScrTagsWnd,
  941.             NULL, (struct TagItem *)ST_CycleTag );
  942.  
  943.     return( TRUE );
  944. }
  945.  
  946. BOOL ScrT_TypeClicked( void )
  947. {
  948.     ScrData.Type = IDCMPMsg.Code;
  949.     return( TRUE );
  950. }
  951. ///
  952.  
  953. /// Screen Font
  954. BOOL ScrFontMenued( void )
  955. {
  956.     struct FontRequester   *req;
  957.  
  958.     if( req = AllocAslRequest( ASL_FontRequest, NULL )) {
  959.  
  960.     if( AslRequestTags( req, ASLFO_InitialHeight, Scr->Height - 40,
  961.                  ASLFO_Screen, Scr,
  962.                  ASLFO_TitleText, CatCompArray[ ASL_SCR_FONT ].cca_Str,
  963.                  ASLFO_DoStyle, -1,
  964.                  ASLFO_MaxHeight, 300,
  965.                  ASLFO_InitialName, ScrData.FontScr,
  966.                  ASLFO_InitialStyle, ScrData.NewFont.ta_Style,
  967.                  ASLFO_InitialSize, ScrData.NewFont.ta_YSize,
  968.                  ASLFO_InitialFlags, ScrData.NewFont.ta_Flags,
  969.                  TAG_DONE )) {
  970.  
  971.         ScrData.NewFont.ta_Style = req->fo_Attr.ta_Style;
  972.         ScrData.NewFont.ta_YSize = req->fo_Attr.ta_YSize;
  973.         ScrData.NewFont.ta_Flags = req->fo_Attr.ta_Flags;
  974.         strcpy( ScrData.FontScr, req->fo_Attr.ta_Name );
  975.  
  976.         ScreenTags2[ SCRFNT ] = &ScrData.NewFont;
  977.  
  978.         UpdateScr();
  979.  
  980.         if( IE.flags_2 & GENERASCR )
  981.         IE.flags &= ~SALVATO;
  982.  
  983.     } else
  984.         Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, MSG_ABORTED );
  985.  
  986.     FreeAslRequest( req );
  987.  
  988.     } else
  989.     Stat( CatCompArray[ ERR_NOASL ].cca_Str, TRUE, 0 );
  990.  
  991.     return( TRUE );
  992. }
  993. ///
  994.  
  995. /// Gadgets Up & Down
  996. void GadgetsUp( void )
  997. {
  998.     struct GadgetInfo *gad;
  999.     struct WindowInfo *wnd;
  1000.  
  1001.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ )
  1002.     for ( gad = wnd->wi_Gadgets.mlh_Head ; gad->g_Node.ln_Succ ; gad = gad->g_Node.ln_Succ ) {
  1003.         BOOL can = FALSE;
  1004.  
  1005.         if( gad->g_Kind < MIN_IEX_ID )
  1006.         can = TRUE;
  1007.         else {
  1008.         struct IEXNode *ex;
  1009.  
  1010.         ex = IE.Expanders.mlh_Head;
  1011.         while( ex->ID != gad->g_Kind )
  1012.             ex = ex->Node.ln_Succ;
  1013.  
  1014.         if( ex->Base->Movable || ex->Base->Resizable )
  1015.             can = TRUE;
  1016.         }
  1017.  
  1018.         if( can )
  1019.         gad->g_Top += YOffset;
  1020.     }
  1021. }
  1022.  
  1023.  
  1024. void GadgetsDown( void )
  1025. {
  1026.     struct GadgetInfo *gad;
  1027.     struct WindowInfo *wnd;
  1028.  
  1029.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ )
  1030.     for ( gad = wnd->wi_Gadgets.mlh_Head ; gad->g_Node.ln_Succ ; gad = gad->g_Node.ln_Succ ) {
  1031.         BOOL can = FALSE;
  1032.  
  1033.         if( gad->g_Kind < MIN_IEX_ID )
  1034.         can = TRUE;
  1035.         else {
  1036.         struct IEXNode *ex;
  1037.  
  1038.         ex = IE.Expanders.mlh_Head;
  1039.         while( ex->ID != gad->g_Kind )
  1040.             ex = ex->Node.ln_Succ;
  1041.  
  1042.         if( ex->Base->Movable || ex->Base->Resizable )
  1043.             can = TRUE;
  1044.         }
  1045.  
  1046.         if( can )
  1047.         gad->g_Top -= YOffset;
  1048.     }
  1049. }
  1050. ///
  1051.  
  1052. /// ScreenMode requester
  1053. BOOL ScrTypeClicked( void )
  1054. {
  1055.     return( ScrTypeMenued() );
  1056. }
  1057.  
  1058. BOOL ScrTypeMenued( void )
  1059. {
  1060.     struct ScreenModeRequester  *req;
  1061.     struct Window               *wnd;
  1062.  
  1063.     if( req = AllocAslRequest( ASL_ScreenModeRequest, NULL )) {
  1064.  
  1065.     wnd = BackWnd;
  1066.     if( IE.flags_2 & DONTUPDATESCR )
  1067.         wnd = NULL;
  1068.  
  1069.     if( buffer = AslRequestTags( req,
  1070.         ASLSM_Window, wnd,
  1071.         ASLSM_TitleText, CatCompArray[ ASL_SCR_TYPE ].cca_Str,
  1072.         ASLSM_InitialDisplayID, ScreenTags2[ SCRID ],
  1073.         ASLSM_InitialDisplayWidth, ScreenTags2[ SCRWIDTH ],
  1074.         ASLSM_InitialDisplayHeight, ScreenTags2[ SCRHEIGHT ],
  1075.         ASLSM_InitialDisplayDepth, ScreenTags2[ SCRDEPTH ],
  1076.         ASLSM_InitialOverscanType, ScreenTags2[ SCROVERSCAN ],
  1077.         ASLSM_InitialAutoScroll, ScreenTags2[ SCRAUTOSCROLL ],
  1078.         ASLSM_DoWidth, TRUE, ASLSM_DoHeight, TRUE,
  1079.         ASLSM_DoDepth, TRUE, ASLSM_DoOverscanType, TRUE,
  1080.         ASLSM_DoAutoScroll, TRUE, TAG_END )) {
  1081.  
  1082.         ScreenTags2[ SCRID         ] = req->sm_DisplayID;
  1083.         ScreenTags2[ SCRWIDTH      ] = req->sm_DisplayWidth;
  1084.         ScreenTags2[ SCRHEIGHT     ] = req->sm_DisplayHeight;
  1085.         ScreenTags2[ SCRDEPTH      ] = req->sm_DisplayDepth;
  1086.         ScreenTags2[ SCROVERSCAN   ] = req->sm_OverscanType;
  1087.         ScreenTags2[ SCRAUTOSCROLL ] = req->sm_AutoScroll;
  1088.  
  1089.         if(!( IE.flags_2 & DONTUPDATESCR ))
  1090.         UpdateScr();
  1091.  
  1092.         if( IE.flags_2 & GENERASCR )
  1093.         IE.flags &= ~SALVATO;
  1094.     }
  1095.  
  1096.     FreeAslRequest( req );
  1097.  
  1098.     } else
  1099.     Stat( CatCompArray[ ERR_NO_ASL ].cca_Str, TRUE, 0 );
  1100.  
  1101.     return( TRUE );
  1102. }
  1103. ///
  1104.  
  1105. /// UpdateScr
  1106. void UpdateScr( void )
  1107. {
  1108.     struct WindowInfo   *wnd;
  1109.     UWORD               old_YOffset;
  1110.  
  1111.     CloseReqs();
  1112.  
  1113.     CheckForVisitors();
  1114.  
  1115.     GadgetsDown();
  1116.  
  1117.     if( ToolsWnd ) {
  1118.     toolsx = ToolsWnd->LeftEdge;
  1119.     toolsy = ToolsWnd->TopEdge;
  1120.     CloseToolsWindow();
  1121.     }
  1122.  
  1123.     IE.win_open    = 0;
  1124.     IE.win_info    = NULL;
  1125.     IE.win_active  = NULL;
  1126.  
  1127.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ ) {
  1128.     if ( wnd->wi_flags1 & W_APERTA ) {
  1129.         CloseWindowSafely( wnd->wi_winptr );
  1130.         wnd->wi_flags1 &= ~W_APERTA;
  1131.         wnd->wi_flags1 |=  W_RIAPRI;
  1132.         wnd->wi_winptr  =  NULL;
  1133.     }
  1134.     }
  1135.  
  1136.     IE.flags |= WNDCHIUSA;
  1137.  
  1138.     CloseBackWindow();
  1139.  
  1140.     old_YOffset = YOffset;
  1141.  
  1142.     if(!( IE.colortable ))
  1143.     GrabPalette();
  1144.  
  1145.     CloseDownScreen();
  1146.  
  1147.     ScreenTags2[19] = (ULONG)CatCompArray[ MSG_STRING_0 ].cca_Str;
  1148.  
  1149.     do {
  1150.  
  1151.     while(!( Scr = OpenScreenTagList( NULL, (struct TagItem *)ScreenTags2 )))
  1152.         if( ScrError() )
  1153.         return;
  1154.  
  1155.     if( IE.colortable ) {
  1156.         if( SysBase->LibNode.lib_Version >= 39 )
  1157.         LoadRGB32( &Scr->ViewPort, (ULONG *)IE.colortable );
  1158.         else
  1159.         LoadRGB4( &Scr->ViewPort, (UWORD *)IE.colortable+2, *((UWORD *)IE.colortable));
  1160.     }
  1161.  
  1162.     ScrData.Visual = VisualInfo = GetVisualInfoA( Scr, NULL );
  1163.  
  1164.     LayoutMenusA( BackMenus, VisualInfo, (struct TagItem *)MenuTag );
  1165.  
  1166.     BackWTags[ WT_WIDTH  ].ti_Data = Scr->Width;
  1167.     BackWTags[ WT_HEIGHT ].ti_Data = Scr->Height;
  1168.  
  1169.     } while( OpenBackWindow() );
  1170.  
  1171.     MyTask->pr_WindowPtr = BackWnd;
  1172.  
  1173.     back_mask = 1 << BackWnd->UserPort->mp_SigBit;
  1174.     signalset = back_mask | 0x1000 | editing_mask | rexx_mask;
  1175.  
  1176.     ScrData.Screen  = Scr;
  1177.     ScrData.YOffset = YOffset = Scr->WBorTop + Scr->Font->ta_YSize;
  1178.     ScrData.XOffset = XOffset = Scr->WBorLeft;
  1179.  
  1180.     old_YOffset = YOffset - old_YOffset;
  1181.  
  1182.     WorkWndTags[ WORKSCR ] = Scr;
  1183.  
  1184.     GadgetsUp();
  1185.  
  1186.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ ) {
  1187.  
  1188.     wnd->wi_Height += old_YOffset;
  1189.  
  1190.     if( wnd->wi_flags1 & W_RIAPRI ) {
  1191.  
  1192.         IE.win_info = wnd;
  1193.  
  1194.         RifaiGadgets();
  1195.  
  1196.         WorkWndTags[ WORKTOP     ] = wnd->wi_Top;
  1197.         WorkWndTags[ WORKLEFT    ] = wnd->wi_Left;
  1198.         WorkWndTags[ WORKHEIGHT  ] = wnd->wi_Height;
  1199.         WorkWndTags[ WORKWIDTH   ] = wnd->wi_Width;
  1200.         WorkWndTags[ WORKTITLE   ] = wnd->wi_name;
  1201.         WorkWndTags[ WORKFLAGS   ] = ( IE.mainprefs & WFLAGS ) ? ( wnd->wi_Flags | WFLG_REPORTMOUSE ) : ( W_F );
  1202.  
  1203.         if( wnd->wi_NumBools ) {
  1204.         struct BooleanInfo *bool;
  1205.  
  1206.         bool = ( struct BooleanInfo * )wnd->wi_Gadgets.mlh_Head;
  1207.  
  1208.         while( bool->b_Kind != BOOLEAN )
  1209.             bool = bool->b_Node.ln_Succ;
  1210.  
  1211.         WorkWndTags[ WORKGADGETS ] = ( ULONG )&bool->b_NextGadget;
  1212.  
  1213.         } else
  1214.         WorkWndTags[ WORKGADGETS ] = ( ULONG )wnd->wi_GList;
  1215.  
  1216.         if(!( wnd->wi_winptr = OpenWindowShdIDCMP( WorkWndTags, WorkWIDCMP ))) {
  1217.         Stat( CatCompArray[ ERR_NOWND ].cca_Str, TRUE, ERR_NOWND );
  1218.         return;
  1219.         }
  1220.  
  1221.         wnd->wi_flags1 &= ~W_RIAPRI;
  1222.         wnd->wi_flags1 |=  W_APERTA;
  1223.  
  1224.         IE.win_active = wnd->wi_winptr;
  1225.  
  1226.         wnd->wi_winptr->UserData = wnd;
  1227.         wnd->wi_winptr->ExtData  = HandleEdit;
  1228.  
  1229.         IE.win_open += 1;
  1230.  
  1231.         if( IE.mainprefs & STACCATI ) {
  1232.         IE.mainprefs &= ~STACCATI;
  1233.         StaccaGadgets();
  1234.         IE.mainprefs |= STACCATI;
  1235.         }
  1236.  
  1237.         RinfrescaFinestra();
  1238.  
  1239.         SetMenuStrip( wnd->wi_winptr, BackMenus );
  1240.         SetPointer( wnd->wi_winptr, puntatore, 13, 16, -7, -6 );
  1241.     }
  1242.     }
  1243.  
  1244.     if( IE.num_win ) {
  1245.     OnMenu( BackWnd, (2<<5)|1 );
  1246.     if( IE.win_open ) {
  1247.         CheckMenuToActive();
  1248.         for( old_YOffset = 0; old_YOffset < ATTIVAMENU_NUOVAW_NUM; old_YOffset++ )
  1249.         OnMenu( BackWnd, attivamenu_nuovawin[ old_YOffset ]);
  1250.     }
  1251.     }
  1252.  
  1253.     opentoolswnd();
  1254.  
  1255.     SistemaMacroMenu();
  1256.  
  1257.     SistemaPrefsMenu();
  1258.  
  1259.     PubScreenStatus( Scr, 0 );
  1260.  
  1261.     if( IE.win_active )
  1262.     ActivateWindow( IE.win_active );
  1263.  
  1264.     IE.flags |= WNDCHIUSA;
  1265. }
  1266.  
  1267.  
  1268.  
  1269. BOOL ScrError( void )
  1270. {
  1271.     ULONG   back = buffer;
  1272.  
  1273.     CloseDownScreen();
  1274.     CloseBackWindow();
  1275.  
  1276.     IE.flags_2 |= DONTUPDATESCR;
  1277.  
  1278.     ScreenToFront( NULL );
  1279.  
  1280.     ScrTypeMenued();
  1281.  
  1282.     IE.flags_2 &= ~DONTUPDATESCR;
  1283.  
  1284.     if( buffer ) {
  1285.     buffer = back;
  1286.     return( FALSE );
  1287.     } else {
  1288.     buffer = back;
  1289.     IE.flags |= ESCI;
  1290.     return( TRUE );
  1291.     }
  1292. }
  1293. ///
  1294.  
  1295. /// CheckForVisitors
  1296. void CheckForVisitors( void )
  1297. {
  1298.     while (!( PubScreenStatus( Scr, PSNF_PRIVATE ) & 1 ))
  1299.     IERequest( CatCompArray[ MSG_UPDATESCR ].cca_Str,
  1300.            ok_txt, MSG_UPDATESCR, 0L );
  1301. }
  1302. ///
  1303.  
  1304. /// CloseReqs
  1305. void CloseReqs( void )
  1306. {
  1307.     CloseDriPensWindow();
  1308.  
  1309.     if( ScrTagsWnd ) {
  1310.     ScrT_OkClicked();
  1311.     CloseScrTagsWindow();
  1312.     }
  1313.  
  1314.     if( LocaleWnd ) {
  1315.     LOC_OkClicked();
  1316.     CloseLocaleWindow();
  1317.     }
  1318.  
  1319.     CloseGenReq();
  1320.  
  1321.     if( MacroWnd ) {
  1322.     GetF();
  1323.     CloseMacroWindow();
  1324.     }
  1325.  
  1326.     if( MainProcWnd ) {
  1327.     MainProcCloseWindow();
  1328.     CloseMainProcWindow();
  1329.     }
  1330.  
  1331.     CloseRexxEdReq();
  1332.  
  1333.     CloseImgBankWindow();
  1334.  
  1335.     if( SrcParamsWnd ) {
  1336.     SP_OkClicked();
  1337.     CloseSrcParamsWindow();
  1338.     }
  1339. }
  1340. ///
  1341.  
  1342. /// RifaiGadgets
  1343. void RifaiGadgets( void )
  1344. {
  1345.     ULONG              *tags;
  1346.     UWORD               kind;
  1347.     int                 cnt;
  1348.     struct Gadget      *last, *next;
  1349.     struct GadgetInfo  *gad;
  1350.     struct IEXNode     *ex;
  1351.  
  1352.  
  1353.     if( IE.win_info->wi_flags1 & W_APERTA )
  1354.     StaccaGadgets();
  1355.  
  1356.     if ( IE.win_info->wi_GList ) {
  1357.     FreeGadgets( IE.win_info->wi_GList );
  1358.     IE.win_info->wi_GList = NULL;
  1359.     }
  1360.  
  1361.     if(!( last = CreateContext( &IE.win_info->wi_GList )))
  1362.     return;
  1363.  
  1364.     if( IE.win_info->wi_NumGads ) {
  1365.  
  1366.     for ( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1367.         kind = gad->g_Kind;
  1368.         if( kind < BOOLEAN ) {
  1369.         void  ( *func )( ULONG *, ULONG, struct GadgetInfo * );
  1370.  
  1371.         tags = newtags_index[ kind - 1 ];
  1372.         SetUnder( tags, gad->g_Tags );
  1373.  
  1374.         func = settag_index[ kind ];
  1375.         ( *func )( tags, gad->g_Tags, gad );
  1376.  
  1377.         if(( kind == MX_KIND ) || ( kind == CYCLE_KIND )) {
  1378.             struct GadgetScelta *gs;
  1379.             ULONG  *point;
  1380.  
  1381.             if( gad->g_ExtraMem )
  1382.             FreeVec( gad->g_ExtraMem );
  1383.  
  1384.             gad->g_ExtraMem = AllocVec(( gad->g_NumScelte << 2 ) + 4, 0L );
  1385.             if (!( tags[ 3 ] = gad->g_ExtraMem ))
  1386.             return;
  1387.  
  1388.             gs = gad->g_Scelte.mlh_Head;
  1389.             point = gad->g_ExtraMem;
  1390.  
  1391.             for ( cnt = 0; cnt < gad->g_NumScelte; cnt++ ) {
  1392.             point[ cnt ] = gs->gs_Node.ln_Name;
  1393.             gs = gs->gs_Node.ln_Succ;
  1394.             }
  1395.             point[ cnt ] = NULL;
  1396.         }
  1397.  
  1398.         gad->g_VisualInfo = VisualInfo;
  1399.  
  1400.         if ( gad->g_Ptr = CreateGadgetA( kind,
  1401.                          last,
  1402.                          (struct NewGadget *)&gad->g_Left,
  1403.                          (struct TagItem *)tags )) {
  1404.             last = gad->g_Ptr;
  1405.         } else
  1406.             DisplayBeep( Scr );
  1407.         }
  1408.     }
  1409.     }
  1410.  
  1411.     for( ex = IE.Expanders.mlh_Head; ex->Node.ln_Succ; ex = ex->Node.ln_Succ ) {
  1412.     IEXBase = ex->Base;
  1413.     if( next = IEX_Make( ex->ID, &IE, last ))
  1414.         last = next;
  1415.     else
  1416.         DisplayBeep( Scr );
  1417.     }
  1418.  
  1419.     if( IE.win_info->wi_NumBools ) {
  1420.  
  1421.     SistemaNextBool();
  1422.  
  1423.     gad = IE.win_info->wi_Gadgets.mlh_Head;
  1424.     while ( gad->g_Kind != BOOLEAN )
  1425.         gad = gad->g_Node.ln_Succ;
  1426.  
  1427.     last = (struct Gadget *)&((struct BooleanInfo *)gad)->b_NextGadget;
  1428.  
  1429.     } else
  1430.     last = IE.win_info->wi_GList;
  1431.  
  1432.  
  1433.     if(( IE.win_info->wi_flags1 & W_APERTA ) && ( IE.win_info->wi_winptr )) {
  1434.  
  1435.     AddGList( IE.win_info->wi_winptr, last, -1, -1, NULL );
  1436.     RefreshGadgets( last, IE.win_info->wi_winptr, NULL );
  1437.     GT_RefreshWindow( IE.win_info->wi_winptr, NULL );
  1438.  
  1439.     if( IE.mainprefs & STACCATI ) {
  1440.         IE.mainprefs &= ~STACCATI;
  1441.         StaccaGadgets();
  1442.         IE.mainprefs |= STACCATI;
  1443.     }
  1444.     }
  1445. }
  1446. ///
  1447.